// SymbolicEngine.pas
unit SymbolicEngine;

interface

uses
  SysUtils, Classes, DataUtils, ucs4unit;

type
  TFact = record
    Subject: string;
    Relation: string;
    Object: string;
    Confidence: Double;
  end;

  TRule = record
    Condition: string; // Логическое выражение
    Action: string;    // Действие/вывод
    Priority: Integer;
  end;

  TSymbolicEngine = class
  private
    FFacts: array of TFact;
    FRules: array of TRule;
    FWorkingMemory: TStringList;
  public
    constructor Create;
    destructor Destroy; override;
    
    procedure AddFact(const Subject, Relation, Object: string; Confidence: Double = 1.0);
    procedure AddRule(const Condition, Action: string; Priority: Integer = 1);
    
    function Infer(const Query: string): TFact;
    function ExecuteRule(const Input: string): string;
    
    procedure SaveToFile(const Filename: string);
    procedure LoadFromFile(const Filename: string);
  end;

implementation

constructor TSymbolicEngine.Create;
begin
  inherited;
  FWorkingMemory := TStringList.Create;
  SetLength(FFacts, 0);
  SetLength(FRules, 0);
  
  // Базовые правила
  AddRule('Contains(Input, "привет")', 'Greeting', 10);
  AddRule('Contains(Input, "пока")', 'Farewell', 10);
  AddRule('Contains(Input, "?") AND Length(Input) > 5', 'Question', 5);
end;

destructor TSymbolicEngine.Destroy;
begin
  FWorkingMemory.Free;
  inherited;
end;

procedure TSymbolicEngine.AddFact(const Subject, Relation, Object: string; Confidence: Double);
begin
  SetLength(FFacts, Length(FFacts) + 1);
  with FFacts[High(FFacts)] do
  begin
    Subject := Subject;
    Relation := Relation;
    Object := Object;
    Confidence := Confidence;
  end;
end;

procedure TSymbolicEngine.AddRule(const Condition, Action: string; Priority: Integer);
begin
  SetLength(FRules, Length(FRules) + 1);
  with FRules[High(FRules)] do
  begin
    Condition := Condition;
    Action := Action;
    Priority := Priority;
  end;
end;

function TSymbolicEngine.ExecuteRule(const Input: string): string;
var
  I: Integer;
  LowerInput: string;
begin
  Result := '';
  LowerInput := UTF8LowerCase(Input);
  
  // Применяем правила в порядке приоритета
  for I := 0 to High(FRules) do
  begin
    if FRules[I].Condition = 'Contains(Input, "привет")' then
    begin
      if LowerInput.Contains('привет') or LowerInput.Contains('здравств') then
      begin
        Result := 'Greeting';
        Exit;
      end;
    end
    else if FRules[I].Condition = 'Contains(Input, "пока")' then
    begin
      if LowerInput.Contains('пока') or LowerInput.Contains('до свидан') then
      begin
        Result := 'Farewell';
        Exit;
      end;
    end
    else if FRules[I].Condition = 'Contains(Input, "?") AND Length(Input) > 5' then
    begin
      if LowerInput.Contains('?') and (Length(Input) > 5) then
      begin
        Result := 'Question';
        Exit;
      end;
    end;
  end;
end;

function TSymbolicEngine.Infer(const Query: string): TFact;
begin
  // Упрощенный вывод - в реальности здесь будет полноценный логический движок
  Result.Subject := '';
  Result.Relation := '';
  Result.Object := '';
  Result.Confidence := 0.0;
end;

procedure TSymbolicEngine.SaveToFile(const Filename: string);
begin
  // Сохранение фактов и правил
end;

procedure TSymbolicEngine.LoadFromFile(const Filename: string);
begin
  // Загрузка фактов и правил
end;

end.

// В AdvancedChatAI.pas
var
  SymbolicEngine: TSymbolicEngine;

procedure Initialize;
begin
  // Существующая инициализация...
  
  // Добавляем символьный движок
  SymbolicEngine := TSymbolicEngine.Create;
  
  // Загружаем базу знаний если есть
  if FileExists('knowledge_base.txt') then
    SymbolicEngine.LoadFromFile('knowledge_base.txt');
end;

procedure EnhancedProcessUserInput;
var
  inputText: ucs4;
  userMessage, ruleResult, finalResponse: string;
  extractedFacts: array of TFact;
  symbolicContext: string;
begin
  // 1. Получаем пользовательский ввод (как раньше)
  UserInput := GetUserInput(POST_FILE, filesList);
  inputText := UserInput.Message;
  userMessage := inputText.ToUTF8.Trim;

  if inputText.Length = 0 then Exit;

  WriteLn('Пользователь: ', userMessage);

  // 2. Символьный анализ
  ruleResult := SymbolicEngine.ExecuteRule(userMessage);
  WriteLn('Символьный анализ: ', ruleResult);

  // 3. Извлекаем факты через трансформер (нейросетевая часть)
  extractedFacts := ExtractFactsWithTransformer(userMessage);
  
  // 4. Добавляем факты в символьную систему
  for I := 0 to High(extractedFacts) do
  begin
    SymbolicEngine.AddFact(extractedFacts[I].Subject, 
                          extractedFacts[I].Relation, 
                          extractedFacts[I].Object,
                          extractedFacts[I].Confidence);
  end;

  // 5. Логический вывод на основе контекста
  symbolicContext := BuildSymbolicContext(ConversationHistory);
  finalResponse := GenerateHybridResponse(userMessage, ruleResult, symbolicContext);

  // 6. Вывод результата
  WriteLn('AI: ', finalResponse);
  UpdateConversationContext('', finalResponse);
end;

function ExtractFactsWithTransformer(const Text: string): array of TFact;
var
  inputMatrix, outputMatrix: TDoubleMatrix;
  entities: TStringArray;
  I: Integer;
begin
  // Используем трансформер для извлечения сущностей и отношений
  inputMatrix := CreateContextEnrichedInput(Text, '');
  ForwardTransformer(TransformerModel, inputMatrix, outputMatrix);
  
  // Преобразуем выход трансформера в факты
  entities := ParseEntitiesFromOutput(outputMatrix);
  
  SetLength(Result, Length(entities) div 3); // Предполагаем формат [субъект, отношение, объект]
  for I := 0 to (Length(entities) div 3) - 1 do
  begin
    Result[I].Subject := entities[I*3];
    Result[I].Relation := entities[I*3+1];
    Result[I].Object := entities[I*3+2];
    Result[I].Confidence := 0.8; // На основе уверенности модели
  end;
end;

function GenerateHybridResponse(const UserMessage, RuleResult, Context: string): string;
begin
  // Комбинируем подходы
  
  // 1. Если символьная система уверена - используем её
  if RuleResult = 'Greeting' then
    Result := 'Здравствуйте! Чем могу помочь?'
  else if RuleResult = 'Farewell' then
    Result := 'До свидания! Рад был пообщаться.'
  else if RuleResult = 'Question' then
  begin
    // Для вопросов используем комбинацию
    if Context.Contains('погод') then
      Result := 'К сожалению, у меня нет доступа к актуальным данным о погоде. '
    else
      Result := 'Интересный вопрос! ';
    
    // Добавляем нейросетевую вариативность
    Result := Result + GenerateTransformerResponse(UserMessage);
  end
  else
    // По умолчанию - нейросеть
    Result := GenerateTransformerResponse(UserMessage);
end;

procedure LearnSymbolicRules(const UserMessage, AIResponse: string);
var
  patterns: TStringArray;
  newRule: string;
begin
  // Анализируем успешные диалоги для извлечения правил
  if ShouldExtractRule(UserMessage, AIResponse) then
  begin
    patterns := ExtractPatterns(UserMessage);
    newRule := BuildRuleFromPatterns(patterns, AIResponse);
    SymbolicEngine.AddRule(newRule, AIResponse, 5);
    
    WriteLn('Добавлено новое правило: ', newRule);
  end;
end;